#!/usr/bin/env python
# -*- coding: UTF-8; indent-tabs-mode:nil; tab-width:4 -*-

# This file is part of DITA DTD Generator.
#
# Copyright 2009 Jarno Elovirta <http://www.elovirta.com/>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Command line interface to DITA DTD Generator."""

import sys
import ditagen.dita
import ditagen.dtdgen
from ditagen.dita.v1_2 import *
from ditagen.dita.v1_1 import *
import ditagen.generator
from optparse import OptionParser

def main():
    """Main method."""
    __type = None
    __remove = {}
    __global_atts = None
    __domains = []
    
    # new arguments
    __parser = OptionParser(usage="usage: %prog [options] type topic [root] [title]",
                            description="DITA Generator.")
    __parser.add_option("-d", "--domain", action="append", dest="domains",
                        help="Add domain DOMAIN", metavar="DOMAIN")
    __parser.add_option("-v", "--version", dest="version", choices=("1.1", "1.2"),
                        help="DITA version. Defaults to 1.1.", metavar="VERSION")
    __parser.add_option("-o", "--owner", dest="owner",
                        help="Owner in FPI.", metavar="OWNER")
    __parser.add_option("-f", "--format", dest="format", choices=("dtd", "mod", "ent", "zip", "plugin"),
                        help="Output format, one of dtd, mod, ent, zip, plugin. Defaults to plugin.", metavar="FORMAT")
    __parser.add_option("-s", "--stylesheet", dest="stylesheet",
                        help="Stylesheet stump base.", metavar="STYLE")
    __parser.add_option("-p", "--plugin-name", dest="plugin_name",
                        help="Plugin name. Defaults to root name.", metavar="PLUGIN")
    __parser.add_option("-n", "--nested", dest="nested", action="store_true",
                        help="Support nested topics.")
    #__parser.add_option("-r", "--root", dest="root",
    #                    help="Root name.", metavar="ROOT")
    #__parser.add_option("-t", "--title", dest="title",
    #                    help="Title.", metavar="TITLE")
    __parser.set_defaults(version="1.1")
    __parser.set_defaults(nested=False)
    __parser.set_defaults(format="plugin")
    (options, args) = __parser.parse_args()
    # read arguments
    if len(args) >= 1:
        if args[0] in ditagen.OUTPUT_MAP:
            __output_type = ditagen.OUTPUT_MAP[args[0]]
        else:
            __parser.error("output type %s not found, supported types: %s."
                           % (args[0], ", ".join(ditagen.OUTPUT_MAP.keys())))
    else:
        __parser.error("output type not set")

    if len(args) >= 2:
        if args[1] in ditagen.TOPIC_MAP[options.version]:
            __type = ditagen.TOPIC_MAP[options.version][args[1]]()
        else:
            __parser.error("topic type %s not found, supported topics: %s."
                           % (args[1], ", ".join(TOPIC_MAP[options.version].keys())))
    else:
        __parser.error("topic not set")
    if len(args) >= 3:
        options.root = args[2]
    if len(args) >= 4:
        options.title = args[3]
    if options.domains != None:
        for __d in options.domains:
            if __d in ditagen.DOMAIN_MAP[options.version]:
                __domains.append(ditagen.DOMAIN_MAP[options.version][__d]())
            else:
                __parser.error("domain %s not found, supported domains: %s."
                               % (__d, ", ".join(ditagen.DOMAIN_MAP[options.version].keys())))
    
    if  hasattr(options, "root") and options.root is not None:
        if hasattr(options, "title") and options.title:
            __t = options.title
        else:
            __t = options.root.capitalize()
        #__type = ditagen.dita.SpecializationType(options.root, __t, __type,
        __type = __output_type(options.root, __t, __type,
                               options.owner, options.root)
    elif options.format in ("mod", "ent", "zip"):
        __parser.error("cannot generate %s for base topic type." % options.format)

    # run generator
    if options.format == u"plugin":
        __dita_gen = ditagen.generator.PluginGenerator()
        __dita_gen.out = sys.stdout
        __dita_gen.topic_type = __type
        __dita_gen.domains = __domains
        __dita_gen.nested = options.nested
        __dita_gen.version = options.version
        if hasattr(options, "title") and  options.title:
            __dita_gen.set_title(options.title)
        if options.stylesheet:
            __dita_gen.set_stylesheet(options.stylesheet)
        __dita_gen.set_plugin_name(options.plugin_name)
        
        __dita_gen.generate_plugin()
    else:
        __dita_gen = ditagen.generator.DitaGenerator()
        __dita_gen.out = sys.stdout
        __dita_gen.topic_type = __type
        __dita_gen.domains = __domains
        __dita_gen.nested = options.nested
        __dita_gen.version = options.version
        if hasattr(options, "title") and  options.title:
            __dita_gen.set_title(options.title)
        
        if options.format == u"dtd":
            #__file_name = __dita_gen.get_file_name(__type, __root, __format)
            __dita_gen.generate_dtd()
        elif options.format == u"mod":
            #__file_name = __dita_gen.get_file_name(__type, __root, __format)
            __dita_gen.generate_mod()
        elif options.format == u"ent":
            #__file_name = __dita_gen.get_file_name(__type, __root, __format)
            __dita_gen.generate_ent()
        elif options.format == u"zip":
            #__file_name = __dita_gen.get_file_name(__type, __root, "zip")
            __dita_gen.generate_zip(sys.stdout)
        #elif __format == u"tgz":
        #    __file_name = __dita_gen.get_file_name(__type, __root, "tar.gz")
        #    __dita_gen.generate_zip(sys.stdout, __type, __domains, __root, __owner, __nested, __remove, __global_atts)
        #elif __format == u"xzip":
        #    __file_name = __dita_gen.get_file_name(__type, __root, "zip")
        #    zip_dita_gen = ditagen.generator.ZipGenerator(sys.stdout)
        #    zip_dita_gen.generate_zip(sys.stdout, __type, __domains, __root, __owner, __nested)

if __name__ == "__main__":
    main()
